package com.fdb.efp.nls.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.fdb.basic.framework.core.base.FrameworkService;
import com.fdb.basic.framework.core.constant.MonAlrmLvlEnums.MonAlrmLvlEnum;
import com.fdb.basic.framework.core.constant.StdZbHandleEnums.StdZbHandleEnum;
import com.fdb.basic.framework.core.util.DateTool;
import com.fdb.basic.framework.core.util.StringUtil;
import com.fdb.basic.framework.core.util.UUIDUtil;
import com.fdb.basic.framework.core.util.ZipUtil;
import com.fdb.efp.nls.common.ImageBizConstant;
import com.fdb.efp.nls.common.UploadFileConstant;
import com.fdb.efp.nls.service.vo.ImageBizInfoVO;
import com.fdb.efp.nls.service.vo.LogErrorInfoVO;
import com.fdb.efp.nls.common.bo.UpLoadFileVO;
import com.fdb.efp.nls.service.facade.ImageBizInfoService;
import com.fdb.efp.nls.service.facade.LogErrorInfoService;
import com.fdb.efp.nls.service.facade.UpLoadFileService;
import com.fdb.efp.nls.service.facade.UpLoadFileToImageSysService;
import com.fdb.efp.esb.common.constant.ElectronicSignatureEnums;
import com.fdb.efp.nls.service.facade.NlsApplyInfoService;
import com.fdb.efp.nls.service.vo.NlsApplyInfoVO;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import java.io.File;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Objects;

/**
 * 
 * 上传文件至影像系统
 * 
 * @author ludayong
 * @since 2019年3月11日 上午11:02:08
 * @version 1.0
 */
@Service("upLoadMsFileToImageSysService")
public class UpLoadMsFileServiceImpl implements UpLoadFileToImageSysService, FrameworkService {

	private final static Logger logger = LoggerFactory.getLogger(UpLoadMsFileServiceImpl.class);
	@Autowired
	@Qualifier("upLoadFileService")
	private UpLoadFileService upLoadFileService;

	@Value("${analysis.archImageFilePath}")
	private String archImageFilePath;// 影像文件归档路径

	@Value("${analysis.archPolicyFilePath}")
	private String archPolicyFilePath;// 保单文件归档路径
	/* weijj:新增了承保意向书文件归档路径 */
	// @Value("${analysis.archInsureFilePath}")
	// private String archInsureFilePath;// 承保意向书文件归档路径

	@Value("${analysis.archSubrogationFilePath}")
	private String archSubrogationFilePath;// 权益转让书归档路径

	@Value("${analysis.uploadNum}")
	private int uploadNum;// 上传影像系统文件/目录个数

	@Autowired
	@Qualifier("logErrorInfoService")
	private LogErrorInfoService logErrorInfoService;// 异常信息表

	@Autowired
	@Qualifier("nlsApplyInfoService")
	private NlsApplyInfoService nlsApplyInfoService;// 网贷申请基本信息

	@Autowired
	@Qualifier("imageBizInfoService")
	private ImageBizInfoService imageBizInfoService;// 影像业务信息

	/**
	 * 
	 * 上传文件至影像系统 <br>
	 * 0.1:ludayong:2019年3月11日 上午11:01:39:新增 <br>
	 * 0.2:ludayong:2019年3月14日 上午13:00:39:增加日志打印 <br>
	 * 
	 * @author ludayong
	 * @since 2019年3月11日 上午11:01:39
	 * @date 2019年3月11日 上午11:01:39
	 * @version 0.2
	 */
	@Override
	public synchronized boolean uploadFile() throws Exception {
		long startTime = System.currentTimeMillis();
		logger.info("上传影像文件到影像系统：[" + DateTool.formatDate(new Date(startTime), DateTool.PATTERN_DATETIME) + "]， 处理开始！");
		boolean result = false;// 上传文件是否成功
		int uploadTotal = 0;
		List<String> states = new ArrayList<String>();
		states.add(StdZbHandleEnum.PENDING.getEnname());// 未处理
		states.add(StdZbHandleEnum.HANGING.getEnname());// 处理中

		LogErrorInfoVO logErrorInfoVo = new LogErrorInfoVO();
		logErrorInfoVo.setState(ElectronicSignatureEnums.YesNoEnum.NO.VALUE);// 未处理

		logger.info("上传影像系统解析路径[" + archImageFilePath + "]！");
		// 解析文件
		File files = new File(archImageFilePath);
		// 文件存在
		if (files.exists()) {
			File[] imageFiles = files.listFiles();
			if (imageFiles.length > 0) {
				logger.info("上传影像系统解析路径下文件的数量[" + imageFiles.length + "]！");
				for (File imageFile : imageFiles) {
					// 处理时间
					long handTime = System.currentTimeMillis() - 5 * 60 * 1000;
					// 文件最后修改时间
					long fileMTime = imageFile.lastModified();
					if (imageFile.isDirectory()) {
						logger.info("处理时间[" + handTime + "]，文件最后修改时间[" + fileMTime + "]");
						// 整笔流水保单
						int num = logErrorInfoService.countByApplySeqAndStates(imageFile.getName(), states);// 错误信息
						if (num >= 3) {
							// 当前申请流水记录累计出现三次异常且未处理，不处理当前申请流水的影像文件
							continue;
						}
						if (uploadTotal >= uploadNum) {
							// 每次上传uploadNum个文件
							break;
						} else if (handTime > fileMTime) {
							// 前置文件服务器上传文件，文件在5分钟以前上传的
							List<UpLoadFileVO> upLoadFilelList = this.handleImageFile(imageFile.getAbsolutePath(), imageFile.getName());
							if (Objects.nonNull(upLoadFilelList) && !upLoadFilelList.isEmpty()) {
								try {
									boolean upImageSysReslut = this.uploadFileToImageSys(imageFile.getName(), imageFile.getAbsolutePath(),
											upLoadFilelList);
									if (upImageSysReslut) {
										// 上传影像文件数
										uploadTotal++;
									}
								} catch (Exception e) {
									String remark = e.getMessage();
									logErrorInfoVo.setApplySeq(imageFile.getName());// 申请流水号
									logErrorInfoVo.setSerno(UUIDUtil.getUUID());// 主键
									String currentTime = DateTool.getCurrentDateTime();// 当前时间
									logErrorInfoVo.setCreateTime(currentTime);// 创建时间
									logErrorInfoVo.setLastModifyTime(currentTime);// 最后修改时间
									insertLogErrorInfo(logErrorInfoVo, remark);
								}
							}
						}
					}
				}
			}
		}
		if (uploadTotal > 0) {
			result = true;
		}
		logger.info("上传影像文件到影像系统，上传数量[" + uploadTotal + "]，处理结果[" + result + "]");
		long endTime = System.currentTimeMillis();
		logger.info("上传影像文件到影像系统：[" + DateTool.formatDate(new Date(endTime), DateTool.PATTERN_DATETIME) + "]， 处理结束！");
		logger.info("上传影像文件到影像系统：，耗时：[" + (endTime - startTime) / 1000.0 + "]秒！");
		return result;
	}

	/**
	 * 
	 * 追加文件文件至影像系统 <br>
	 * 0.1:ludayong:2019年3月11日 上午11:02:45:新增 <br>
	 * 0.2:ludayong:2019年3月14日 上午13:00:39:增加日志打印 <br>
	 * 
	 * @author ludayong
	 * @since 2019年3月11日 上午11:02:45
	 * @date 2019年3月11日 上午11:02:45
	 * @version 0.2
	 */
	@Override
	public synchronized boolean updateBatchFile() throws Exception {
		long startTime = System.currentTimeMillis();
		logger.info("追加影像文件到影像系统：[" + DateTool.formatDate(new Date(startTime), DateTool.PATTERN_DATETIME) + "]， 处理开始！");

		// 错误信息
		LogErrorInfoVO logErrorInfoVo = new LogErrorInfoVO();
		logErrorInfoVo.setState(ElectronicSignatureEnums.YesNoEnum.NO.VALUE);// 未处理
		boolean resultPolicy = false;
		try {
			// 追加保单文件到影像系统
			logger.info("追加保单文件到影像系统解析路径[" + archPolicyFilePath + "]！");
			resultPolicy = updateDetailBatchFile(archPolicyFilePath, ImageBizConstant.IMAGE_TYPE_A06);
			logger.info("上传保单影像文件到影像系统，处理结果[" + resultPolicy + "]");
		} catch (Exception e) {
			String remark = "上传保单文件到影像系统，出现异常：" + e.getMessage();
			logErrorInfoVo.setSerno(UUIDUtil.getUUID());// 主键
			String currentTime = DateTool.getCurrentDateTime();// 当前时间
			logErrorInfoVo.setCreateTime(currentTime);// 创建时间
			logErrorInfoVo.setLastModifyTime(currentTime);// 最后修改时间
			insertLogErrorInfo(logErrorInfoVo, remark);
		}
		 boolean resultSubrogation = false;
		 try {
			 // 追加权益转让书到影像系统
			 logger.info("追加权益转让书到影像系统解析路径[" + archSubrogationFilePath + "]！");
			 resultSubrogation = updateDetailBatchFile(archSubrogationFilePath, ImageBizConstant.IMAGE_TYPE_A07);
			 logger.info("上传权益转让书到影像系统，处理结果[" + resultSubrogation + "]");
		 } catch (Exception e) {
			 String remark = "上传权益转让书到影像系统，出现异常：" + e.getMessage();
			 logErrorInfoVo.setSerno(UUIDUtil.getUUID());// 主键
			 String currentTime = DateTool.getCurrentDateTime();// 当前时间
			 logErrorInfoVo.setCreateTime(currentTime);// 创建时间
			 logErrorInfoVo.setLastModifyTime(currentTime);// 最后修改时间
			 insertLogErrorInfo(logErrorInfoVo, remark);
		 }

		long endTime = System.currentTimeMillis();
		logger.info("追加影像文件到影像系统：[" + DateTool.formatDate(new Date(endTime), DateTool.PATTERN_DATETIME) + "]， 处理结束！");
		logger.info("追加影像文件到影像系统：，耗时：[" + (endTime - startTime) / 1000.0 + "]秒！");
		return resultPolicy || resultSubrogation;
	}

	/**
	 * 
	 * 追加文件文件至影像系统 <br>
	 * 0.1:ludayong:2019年3月11日 上午11:03:01:新增 <br>
	 * 
	 * @author ludayong
	 * @since 2019年3月11日 上午11:03:01
	 * @date 2019年3月11日 上午11:03:01
	 * @version 0.1
	 */
	public boolean updateDetailBatchFile(String archPath, String imageType) throws Exception {
		boolean result = false;// 上传文件是否成功
		int uploadTotal = 0;

		LogErrorInfoVO logErrorInfoVo = new LogErrorInfoVO();
		logErrorInfoVo.setState(ElectronicSignatureEnums.YesNoEnum.NO.VALUE);// 未处理

		// 解析文件
		File files = new File(archPath);
		// 文件存在
		if (files.exists()) {
			File[] archFiles = files.listFiles();
			logger.info("追加文件到影像系统解析路径[" + archPath + "" + "解析路径下文件数量" + archFiles.length + "]!");
			if (archFiles.length > 0) {
				for (File archFile : archFiles) {
					// 处理时间
					long handTime = System.currentTimeMillis() - 5 * 60 * 1000;
					// 文件最后修改时间
					long fileMTime = archFile.lastModified();
					logger.info("处理时间[" + handTime + "]，文件最后修改时间[" + fileMTime + "]");
					if (archFile.isDirectory()) {
						if (uploadTotal >= uploadNum) {
							// 每次上传downNum个文件
							break;
						} else if (handTime > fileMTime) {
							// 前置文件服务器上传文件，文件在5分钟以前上传的
							try {
								boolean upImageSysReslut = this.handleBatchFile(archFile.getName(), archFile.getAbsolutePath(), imageType);
								if (upImageSysReslut) {
									// 上传影像文件数
									uploadTotal++;
								}
							} catch (Exception e) {
								String remark = e.getMessage();
								logErrorInfoVo.setApplySeq(archFile.getName());// 申请流水号
								logErrorInfoVo.setSerno(UUIDUtil.getUUID());// 主键
								String currentTime = DateTool.getCurrentDateTime();// 当前时间
								logErrorInfoVo.setCreateTime(currentTime);// 创建时间
								logErrorInfoVo.setLastModifyTime(currentTime);// 最后修改时间
								insertLogErrorInfo(logErrorInfoVo, remark);
							}
						}
					}
				}
			}
		}
		if (uploadTotal > 0) {
			result = true;
		}
		return result;
	}

	/**
	 * 
	 * 上传文件至影像系统 <br>
	 * 0.1:ludayong:2019年3月11日 上午11:03:16:新增 <br>
	 * 
	 * @author ludayong
	 * @since 2019年3月11日 上午11:03:16
	 * @date 2019年3月11日 上午11:03:16
	 * @version 0.1
	 */
	public boolean uploadFileToImageSys(String applySeq, String filePath, List<UpLoadFileVO> upLoadFilelList) throws Exception {
		boolean result = false;
		boolean upImageSysReslut = false;// 上传影像文件到影像系统处理结果
		if (Objects.nonNull(upLoadFilelList) && !upLoadFilelList.isEmpty()) {
			String startDate = upLoadFilelList.get(0).getStartDate(); // 流水号生成时间 yyyymmdd
			// 客户证件号码
			String certCode = upLoadFilelList.get(0).getCertCode();
			// 客户名称
			String cusName = upLoadFilelList.get(0).getCusName();
			// 产品名称
			String prdName = upLoadFilelList.get(0).getPrdName();

			if (Objects.nonNull(upLoadFilelList) && !upLoadFilelList.isEmpty()) {
				UpLoadFileVO vo = new UpLoadFileVO();
				vo.setApplySeq(applySeq);
				// 先查询该申请信息是否有上传过影像系统
				List<UpLoadFileVO> liatVo = upLoadFileService.queryUploadFile(vo);
				if (Objects.nonNull(liatVo) && !liatVo.isEmpty()) {
					for (UpLoadFileVO upLoadFileVo : upLoadFilelList) {
						this.updateBatchFileToImageSys(upLoadFileVo.getFilePath(), applySeq, upLoadFileVo.getImageType());
					}
					result = true;
				} else {
					// 影像平台上传信息
					UpLoadFileVO upLoadFileVO = new UpLoadFileVO();
					// 申请流水号
					upLoadFileVO.setApplySeq(applySeq);
					// 流水号生成时间 yyyymmdd
					upLoadFileVO.setStartDate(startDate);
					// 证件号码
					upLoadFileVO.setCertCode(certCode);
					// 客户名称
					upLoadFileVO.setCusName(cusName);
					// 产品名称
					upLoadFileVO.setPrdName(prdName);

					// 该申请信息第一次上传影像系统
					String ret = UploadFileConstant.uploadFile(upLoadFileVO, filePath);// 上传影像系统
					String[] rets = ret.split("<<::>>");
					for (UpLoadFileVO upLoadFileVo : upLoadFilelList) {
						// String ret = "SUCCESS<<::>>20190116-E3BD0CCF-FE36-951F-88F3-38821BF7A50C-1";
						// SUCCESS<<::>>20190116-E3BD0CCF-FE36-951F-88F3-38821BF7A50C-1
						// FAIL<<::>>20190116-F453F865-2103-7FC1-A605-1C39AD4799AE-1<<::>>743
						if (StringUtil.isNullorBank(ret)) {// 失败
							String remark = "影像文件上传影像系统出错，错误信息：";
							throw new Exception(remark + ret);
						} else if (rets.length > 2) {// 失败
							upLoadFileVo.setState(rets[0]);// 状态
							upLoadFileVo.setBatch(rets[1]);// 返回批次号
							upLoadFileVo.setStateNum(rets[2]);// 失败状态码

							String remark = "影像文件上传影像系统出错，错误信息：";
							throw new Exception(remark + ret);
						} else {
							upLoadFileVo.setState(rets[0]);// 状态
							upLoadFileVo.setBatch(rets[1]);// 返回批次号
							upImageSysReslut = true;// 上传影像文件到影像系统处理结果
						}
					}
					int listSize = 0;// 上传影像系统信息数据条数
					int upLoadFileNum = 0;// 新增/更新上传影像系统信息数据条数
					if (upImageSysReslut) {// 上传影像文件到影像系统处理结果
						logger.info("当前新增/更新上传影像系统信息数据为:" + JSONObject.toJSONString(upLoadFilelList));
						// 文件移动后新增/更新影像业务文件数据
						if (Objects.nonNull(upLoadFilelList) && !upLoadFilelList.isEmpty()) {
							// 上传影像系统信息数据条数
							listSize = upLoadFilelList.size();
							for (UpLoadFileVO upLoadFileVo : upLoadFilelList) {
								UpLoadFileVO queryUpLoadFileVO = upLoadFileService.queryUploadFileByApplySeqAndImageType(upLoadFileVo);
								if (Objects.nonNull(queryUpLoadFileVO) && !StringUtil.isNullorBank(queryUpLoadFileVO.getApplySeq())) {
									// 文件上传成功后，会删除本地文件
									upLoadFileVo.setFilePath(" ");
									upLoadFileNum += upLoadFileService.updateUpLoadFile(upLoadFileVo);
								} else {
									// 文件上传成功后，会删除本地文件
									upLoadFileVo.setFilePath(" ");
									upLoadFileNum += upLoadFileService.insertUpLoadFile(upLoadFileVo);
								}
							}
						}
						logger.info("当前新增/更新上传影像系统信息数据条数为:" + upLoadFileNum);

						// 更新影像业务信息传送给影像系统为成功
						ImageBizInfoVO imageBizInfoVO = new ImageBizInfoVO();// 影像业务信息
						imageBizInfoVO.setApplySeq(applySeq);// 申请流水号
						imageBizInfoVO.setSoltImageThird1(ImageBizConstant.YesNoEnum.YES.VALUE);// 传送给影像系统
						imageBizInfoVO.setLastModifyTime(DateTool.getCurrentDateTime());// 最近修改时间

						boolean bizInfoRes = updateImageBizInfo(imageBizInfoVO);
						logger.info("更新影像业务信息结果:" + bizInfoRes);
					}
					if (upLoadFileNum > 0 && listSize == upLoadFileNum) {
						result = true;
					}
				}
			}
		}

		File analysisFile = new File(filePath);
		if (result) {
			if (analysisFile.exists()) {
				// 上传文件成功，删除目录
				boolean removeResult = ZipUtil.deleteFolder(filePath);
				logger.info("删除目录，目标路径:" + filePath + "结果[" + removeResult + "]");
			}
		}
		if (analysisFile.exists()) {
			File[] analysisFiles = analysisFile.listFiles();
			if (analysisFiles.length == 0) {
				// 路径为目录且为空则进行删除
				boolean removeResult = ZipUtil.deleteFolder(filePath);
				logger.info("删除空目录，目标路径:" + filePath + "结果[" + removeResult + "]");
			}
		}
		return result;
	}

	/**
	 * 
	 * 追加文件文件至影像系统 <br>
	 * 0.1:ludayong:2019年3月11日 上午11:03:31:新增 <br>
	 * 
	 * @author ludayong
	 * @since 2019年3月11日 上午11:03:31
	 * @date 2019年3月11日 上午11:03:31
	 * @version 0.1
	 */
	public boolean updateBatchFileToImageSys(String filePath, String applySeq, String imageType) throws Exception {
		boolean result = false;
		boolean upImageSysReslut = false;// 追加文件到影像系统处理结果
		int upLoadFileNum = 0;// 新增/更新上传影像系统信息数据条数

		UpLoadFileVO vo = new UpLoadFileVO();
		vo.setApplySeq(applySeq);
		String batch = "";
		String startDate = "";
		String ret = "";
		UpLoadFileVO upLoadFileVo = new UpLoadFileVO();

		logger.info("追加文件到影像系统开始:" + filePath + "*******" + applySeq);

		String currentTime = DateTool.getCurrentDateTime();// 当前时间
		List<UpLoadFileVO> liatVo = upLoadFileService.queryUploadFile(vo);
		if (Objects.nonNull(liatVo) && !liatVo.isEmpty()) {
			batch = liatVo.get(0).getBatch();// 查询批次号
			startDate = liatVo.get(0).getStartDate();// 查询流水生成时间
			// 客户证件号码
			String certCode = liatVo.get(0).getCertCode();
			// 客户名称
			String cusName = liatVo.get(0).getCusName();
			// 产品名称
			String prdName = liatVo.get(0).getPrdName();

			upLoadFileVo.setApplySeq(applySeq);// 流水号
			upLoadFileVo.setImageType(imageType);// 影像类型
			upLoadFileVo.setStartDate(startDate);// 流水号生成时间 yyyymmdd
			// upLoadFileVo.setState(state);//状态
			// upLoadFileVo.setStateNum(stateNum);//状态标识
			upLoadFileVo.setBatch(batch);// 批次号码
			upLoadFileVo.setFilePath(filePath);// 上传文件路径
			upLoadFileVo.setCreateTime(currentTime);// 创建时间
			upLoadFileVo.setLastModifyTime(currentTime);// 最近修改时间
			// 证件号码
			upLoadFileVo.setCertCode(certCode);
			// 客户名称
			upLoadFileVo.setCusName(cusName);
			// 产品名称
			upLoadFileVo.setPrdName(prdName);

			UpLoadFileVO queryUpLoadFileVO = upLoadFileService.queryUploadFileByApplySeqAndImageType(upLoadFileVo);
			String queryUpdate = UploadFileConstant.queryBatchFile(batch, startDate, "");
			if (Objects.nonNull(queryUpLoadFileVO) && !StringUtil.isNullorBank(queryUpLoadFileVO.getApplySeq())) {
				// 更新替换文件
				ret = UploadFileConstant.updateReplaceBatchFile(queryUpdate, batch, filePath, startDate, imageType);
			} else {
				// 追加文件
				ret = UploadFileConstant.updateBatchFile(applySeq, batch, filePath, startDate);
			}
			logger.info("追加文件到影像系统返回信息:" + ret);
			// 成功 返回成功信息SUCCESS
			// 失败 返回失败信息+异常代码,例如: FAIL<<::>>733
			if (ImageBizConstant.SUCCESS.equals(ret)) {// 成功
				upLoadFileVo.setAddFileState(ret);// 追加文件状态
				upImageSysReslut = true;// 上传文件到影像系统处理结果
			} else {
				upImageSysReslut = false;
				String remark = "追加文件到影像系统出错，异常信息:";
				throw new Exception(remark + ret);
			}
			if (upImageSysReslut) {// 上传文件到影像系统处理结果
				logger.info("当前新增/更新上传影像系统信息数据为:" + JSONObject.toJSONString(upLoadFileVo));
				if (Objects.nonNull(queryUpLoadFileVO) && !StringUtil.isNullorBank(queryUpLoadFileVO.getApplySeq())) {
					// 文件上传成功后，会删除本地文件
					upLoadFileVo.setFilePath(" ");
					upLoadFileNum = upLoadFileService.updateUpLoadFile(upLoadFileVo);
				} else {
					// 文件上传成功后，会删除本地文件
					upLoadFileVo.setFilePath(" ");
					upLoadFileNum = upLoadFileService.insertUpLoadFile(upLoadFileVo);
				}
				logger.info("当前新增/更新上传影像系统信息数据条数为:" + upLoadFileNum);

				// 更新影像业务信息传送给影像系统为成功
				ImageBizInfoVO imageBizInfoVO = new ImageBizInfoVO();// 影像业务信息
				imageBizInfoVO.setApplySeq(applySeq);// 申请流水号
				imageBizInfoVO.setSoltImageThird1(ImageBizConstant.YesNoEnum.YES.VALUE);// 传送给影像系统
				imageBizInfoVO.setLastModifyTime(DateTool.getCurrentDateTime());// 最近修改时间

				boolean bizInfoRes = updateImageBizInfo(imageBizInfoVO);
				logger.info("更新影像业务信息结果:" + bizInfoRes);
			}
		} else {
			upImageSysReslut = false;
			String remark = "该文件没有找到关联影像文件在影像系统的批次号！";
			logger.info(remark);
		}
		if (upLoadFileNum > 0) {
			result = true;
		}
		// 追加影像文件成功
		if (result) {
			boolean removeResult = ZipUtil.deleteFile(filePath);// 删除文件
			logger.info("删除文件，目标路径:" + filePath + "结果[" + removeResult + "]");
		}
		return result;
	}

	/**
	 * 
	 * 上传影像系统文件信息 <br>
	 * 0.1:ludayong:2019年3月11日 上午11:03:49:新增 <br>
	 * 
	 * @author ludayong
	 * @since 2019年3月11日 上午11:03:49
	 * @date 2019年3月11日 上午11:03:49
	 * @version 0.1
	 */
	public List<UpLoadFileVO> handleImageFile(String analysisPath, String fileName) {
		// 申请流水号
		String applySeq = fileName;
		List<UpLoadFileVO> upLoadFilelList = new ArrayList<UpLoadFileVO>();// 上传影像系统
		// 网贷申请基本信息
		NlsApplyInfoVO inNlsApplyInfoVO = new NlsApplyInfoVO();
		inNlsApplyInfoVO.setApplySeq(applySeq);
		NlsApplyInfoVO queryNlsApplyInfoVO = nlsApplyInfoService.queryByPk(inNlsApplyInfoVO);// 查询网贷申请基本信息

		String currentTime = DateTool.getCurrentDateTime();// 当前时间
		LogErrorInfoVO logErrorInfoVo = new LogErrorInfoVO();
		logErrorInfoVo.setApplySeq(applySeq);// 申请流水号
		logErrorInfoVo.setSerno(UUIDUtil.getUUID());// 主键
		logErrorInfoVo.setState(ElectronicSignatureEnums.YesNoEnum.NO.VALUE);// 未处理
		logErrorInfoVo.setCreateTime(currentTime);// 创建时间
		logErrorInfoVo.setLastModifyTime(currentTime);// 最后修改时间

		try {
			Objects.requireNonNull(queryNlsApplyInfoVO);// 网贷申请基本信息不为空
		} catch (Exception e) {
			e.printStackTrace();
			String remark = "网贷申请基本信息为空！";
			logErrorInfoVo.setTableName("nls_apply_info");// 表名
			insertLogErrorInfo(logErrorInfoVo, remark);
			return null;
		}

		File files = new File(analysisPath);
		File[] imgFiles = files.listFiles();
		for (File imgFile : imgFiles) {
			String imageFileName = imgFile.getName();// 文件名
			String imgFileName = imageFileName.replace(applySeq + "_", "");// 去除申请流水号文件名
			String imageId = imgFileName.indexOf(".") >= 0 ? imgFileName.substring(0, imgFileName.indexOf(".")) : "";// 影像标识

			UpLoadFileVO upLoadFileVO = new UpLoadFileVO();// 上传影像系统信息
			upLoadFileVO.setApplySeq(applySeq);// 申请流水号
			upLoadFileVO.setFilePath(imgFile.getAbsolutePath());// 上传文件路径
			// 证件号码
			upLoadFileVO.setCertCode(queryNlsApplyInfoVO.getCertCode());
			// 客户名称
			upLoadFileVO.setCusName(queryNlsApplyInfoVO.getCusName());
			// 产品名称
			upLoadFileVO.setPrdName(queryNlsApplyInfoVO.getPrdName());

			String currentDate = new SimpleDateFormat("yyyyMMdd").format(new Date());// 流水号生成时间 yyyymmdd

			if (!StringUtil.isNullorBank(queryNlsApplyInfoVO.getApplyDate())) {
				currentDate = queryNlsApplyInfoVO.getApplyDate().replaceAll("-", "");
			}
			upLoadFileVO.setStartDate(currentDate);// 流水号生成时间

			switch (imageId) {
			case ImageBizConstant.FILE_SIGN_CERT_F:
				upLoadFileVO.setImageType(ImageBizConstant.IMAGE_TYPE_A01);// 影像类型
				break;
			case ImageBizConstant.FILE_SIGN_CERT_B:
				upLoadFileVO.setImageType(ImageBizConstant.IMAGE_TYPE_A02);// 影像类型
				break;
			case ImageBizConstant.FILE_SIGN_FACE:
				upLoadFileVO.setImageType(ImageBizConstant.IMAGE_TYPE_A03);// 影像类型
				break;
			case ImageBizConstant.FILE_SIGN_CREDIT_AUTH:
				upLoadFileVO.setImageType(ImageBizConstant.IMAGE_TYPE_A04);// 影像类型
				break;
			case ImageBizConstant.FILE_SIGN_LOAN_PROTOCOL:
				upLoadFileVO.setImageType(ImageBizConstant.IMAGE_TYPE_A05);// 影像类型
				break;
			case ImageBizConstant.FILE_SIGN_LOAN_POLICY:
				upLoadFileVO.setImageType(ImageBizConstant.IMAGE_TYPE_A06);// 影像类型
				break;
			case ImageBizConstant.FILE_SIGN_LOAN_INSURE:
				upLoadFileVO.setImageType(ImageBizConstant.IMAGE_TYPE_A08);// 影像类型
				break;
			default:
				boolean removeFileRes = ZipUtil.deleteFile(imgFile.getAbsolutePath());
				logger.info("清理未识别的影像文件，目标路径：" + imgFile.getAbsolutePath() + "，结果[" + removeFileRes + "]");
				break;
			}
			upLoadFileVO.setCreateTime(currentTime);// 创建时间
			upLoadFileVO.setLastModifyTime(currentTime);// 最近修改时间
			upLoadFileVO.setCertCode(queryNlsApplyInfoVO.getCertCode()); // 客户证件号码
			upLoadFilelList.add(upLoadFileVO);
		}
		return upLoadFilelList;
	}

	/**
	 * 
	 * 追加文件文件至影像系统 <br>
	 * 0.1:ludayong:2019年3月11日 上午11:04:02:新增 <br>
	 * 
	 * @author ludayong
	 * @since 2019年3月11日 上午11:04:02
	 * @date 2019年3月11日 上午11:04:02
	 * @version 0.1
	 */
	public boolean handleBatchFile(String applySeq, String policFilePath, String imageType) throws Exception {
		boolean result = false;// 上传文件是否成功
		List<String> states = new ArrayList<String>();
		states.add(StdZbHandleEnum.PENDING.getEnname());// 未处理
		states.add(StdZbHandleEnum.HANGING.getEnname());// 处理中

		File imageFile = new File(policFilePath);
		File[] imgFiles = imageFile.listFiles();

		if (imgFiles.length > 0) {
			for (File imgFile : imgFiles) {
				logger.info("追加影像文件到影像系统，目标路径文件数量:" + imgFiles.length);
				if (imgFile.isFile()) {
					logger.info("追加影像文件到影像系统，目标路径:" + imgFile.getAbsolutePath());
					int num = 0;
					if (ImageBizConstant.IMAGE_TYPE_A06.equals(imageType)) {
						// 单个保单文件
						String loanPolicy = imgFile.getName().substring(0, imgFile.getName().indexOf("."));// 保单号
						num = logErrorInfoService.countByApplySeqAndStates(loanPolicy, states);
					} else if (ImageBizConstant.IMAGE_TYPE_A07.equals(imageType)) {
						String loanInsure = imgFile.getName().substring(0, imgFile.getName().indexOf("_"));// 借据号
						num = logErrorInfoService.countByApplySeqAndStates(loanInsure, states);
					} else {
						// 错误信息
						num = logErrorInfoService.countByApplySeqAndStates(applySeq, states);// 错误信息
					}
					if (num >= 3) {
						// 当前申请流水记录累计出现三次异常且未处理，不处理当前申请流水的影像文件
						continue;
					} else {
						result = this.updateBatchFileToImageSys(imgFile.getAbsolutePath(), applySeq, imageType);
					}
				}
			}
		}
		File analysisFile = new File(policFilePath);
		if (analysisFile.exists()) {
			File[] analysisFiles = analysisFile.listFiles();
			if (analysisFiles.length == 0) {
				// 路径为目录且为空则进行删除
				boolean removeResult = ZipUtil.deleteFolder(policFilePath);
				logger.info("删除空目录，目标路径:" + policFilePath + "结果[" + removeResult + "]");
			}
		}
		return result;
	}

	/**
	 * 新增影像业务信息
	 * 
	 * @param imageBizInfoVO
	 * 
	 * @return
	 * @author ludayong
	 * @since 2019年1月17日 下午8:40:42
	 * @version 1.0
	 */
	private boolean updateImageBizInfo(ImageBizInfoVO imageBizInfoVO) {
		int bizInfoNum = 0;// 新增/更新影像业务信息数据条数
		boolean reslut = false;
		logger.info("当前新增/更新影像业务信息数据为:" + JSONObject.toJSONString(imageBizInfoVO));
		ImageBizInfoVO queryImageBizInfoVO = imageBizInfoService.queryByPk(imageBizInfoVO);
		if (queryImageBizInfoVO != null) {
			bizInfoNum = imageBizInfoService.updateByPk(imageBizInfoVO);
		} else {
			bizInfoNum = imageBizInfoService.insertImageBizInfo(imageBizInfoVO);
		}
		logger.info("当前新增/更新影像业务信息数据条数为:" + bizInfoNum);

		if (bizInfoNum > 0) {
			reslut = true;
		}
		return reslut;
	}

	/**
	 * 
	 * 新增错误信息 <br>
	 * 0.1:weijj:2019年4月28日 下午8:53:02:新增 <br>
	 * 
	 * @author weijj
	 * @since 2019年4月28日 下午8:53:02
	 * @date 2019年4月28日 下午8:53:02
	 * @version 0.1
	 */
	public void insertLogErrorInfo(LogErrorInfoVO logErrorInfoVo, String remark) {
		logErrorInfoVo.setErrorMsg(remark);// 错误信息
		logErrorInfoVo.setRemark(remark);// 备注
		logErrorInfoVo.setErrorType(MonAlrmLvlEnum.SERIOUS.getEnname());// 错误级别
		logErrorInfoService.insertLogErrorInfo(logErrorInfoVo);// 记录错误信息
	}
}